package solutions.ferpa.ztest.ent;

import java.sql.*;
import java.util.ArrayList;
import br.com.telescope.adsrt.dom.*;
import br.com.telescope.adsrt.lib.*;
import br.com.telescope.t2.exception.Severity;

/**
 * API de persistência de dados da entidade VARIAVEL_APLICATIVO
 * @author Gerado pelo Telescope
 */
public class EntVariavelAplicativo extends Entity {
    
    public final static String ENTITY_NAME = "ZTEST.VARIAVEL_APLICATIVO";
    public final static String TABLE_NAME = "VARIAVEL_APLICATIVO";
    
    // <editor-fold defaultstate="collapsed" desc="Contrutores e inicializacao">
    /**
     * Construtores
     */
    public EntVariavelAplicativo() {
        super();
        initialize();
    }
    
    public EntVariavelAplicativo(BaseRuntime ctx) {
        super();
        initialize(ctx);
    }
    
    @Override
    public String getPrimaryKeyColumn() {
        return "ID";
    }
    
    @Override
    public void initialize(BaseRuntime ctx) {
        super.initialize(ctx);
        initialize();
    }
    
    public void initialize() {
        aId = new DomId(this,"ID", "Id"); 
        aId.setRequired(true);
        oId = new DomId();
        aNome = new DomUpper(this,"NOME", "Nome da variável"); 
        aNome.setRequired(true);
        oNome = new DomUpper();
        aAplicativoOperacaoId = new DomId(this,"APLICATIVO_OPERACAO_ID", "Aplicativo de operação"); 
        aAplicativoOperacaoId.setRequired(true);
        oAplicativoOperacaoId = new DomId();
        aMascaraValor = new DomText(this,"MASCARA_VALOR", "Máscara de valor da variável"); 
        aMascaraValor.setSize(32);
        oMascaraValor = new DomText();
        aTipoVariavelAplicativoId = new DomId(this,"TIPO_VARIAVEL_APLICATIVO_ID", "Tipo da variável de aplicativo"); 
        aTipoVariavelAplicativoId.setRequired(true);
        oTipoVariavelAplicativoId = new DomId();
        aValorDefault = new DomProperties(this,"VALOR_DEFAULT", "Valor default para a variável"); 
        aValorDefault.setSize(512);
        oValorDefault = new DomProperties();
        aUnidadeMedida = new DomUpper(this,"UNIDADE_MEDIDA", "Unidade de medida do valor"); 
        oUnidadeMedida = new DomUpper();
        aProcessoAplicativoId = new DomId(this,"PROCESSO_APLICATIVO_ID", "Processo do aplicativo"); 
        oProcessoAplicativoId = new DomId();
        ressetModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributos da entidade">
    
    // Id
    private DomId aId;
    private DomId oId;
    
    // Nome da variável
    private DomUpper aNome;
    private DomUpper oNome;
    
    // Aplicativo de operação
    private DomId aAplicativoOperacaoId;
    private DomId oAplicativoOperacaoId;
    
    // Máscara de valor da variável
    private DomText aMascaraValor;
    private DomText oMascaraValor;
    
    // Tipo da variável de aplicativo
    private DomId aTipoVariavelAplicativoId;
    private DomId oTipoVariavelAplicativoId;
    
    // Valor default para a variável
    private DomProperties aValorDefault;
    private DomProperties oValorDefault;
    
    // Unidade de medida do valor
    private DomUpper aUnidadeMedida;
    private DomUpper oUnidadeMedida;
    
    // Processo do aplicativo
    private DomId aProcessoAplicativoId;
    private DomId oProcessoAplicativoId;
    
    // <editor-fold defaultstate="collapsed" desc="Atributo ID">
    
    public EntVariavelAplicativo id(Long value) {
        setId(value);
        return this;
    }
    
    public void setId(DomId value) {
        if (value == null || value.isNull()) {
            nullifyId();
        } else {
            aId.setValue(value.getValue());
            if (aId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setId(String value) {
        if (value == null) {
            nullifyId();
        } else {
            aId.setValue(value);
            if (aId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setId(Long value) {
        aId.setValue(value);
        if (aId.isModified()) {
            setModified(true);
        }
    }
    
    public void setId(Object value) {
        aId.setValue(value);
        if (aId.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyId() {
        if (!aId.isNull()) {
            aId.setNull(true);
            setModified(true);
        }
    }
    
    public DomId getId() {
        return aId;
    }
    
    public DomId oldId() {
        return oId;
    }
    
    public Long valueOfId() {
        return aId.getValue();
    }
    
    public boolean isIdModified() {
        return aId.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo NOME">
    
    public EntVariavelAplicativo nome(String value) {
        setNome(value);
        return this;
    }
    
    public void setNome(DomUpper value) {
        if (value == null || value.isNull()) {
            nullifyNome();
        } else {
            aNome.setValue(value.getValue());
            if (aNome.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setNome(String value) {
        if (value == null) {
            nullifyNome();
        } else {
            aNome.setValue(value);
            if (aNome.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setNome(Object value) {
        aNome.setValue(value);
        if (aNome.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyNome() {
        if (!aNome.isNull()) {
            aNome.setNull(true);
            setModified(true);
        }
    }
    
    public DomUpper getNome() {
        return aNome;
    }
    
    public DomUpper oldNome() {
        return oNome;
    }
    
    public String valueOfNome() {
        return aNome.getValue();
    }
    
    public boolean isNomeModified() {
        return aNome.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo APLICATIVO_OPERACAO_ID">
    
    public EntVariavelAplicativo aplicativoOperacaoId(Long value) {
        setAplicativoOperacaoId(value);
        return this;
    }
    
    public void setAplicativoOperacaoId(DomId value) {
        if (value == null || value.isNull()) {
            nullifyAplicativoOperacaoId();
        } else {
            aAplicativoOperacaoId.setValue(value.getValue());
            if (aAplicativoOperacaoId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setAplicativoOperacaoId(String value) {
        if (value == null) {
            nullifyAplicativoOperacaoId();
        } else {
            aAplicativoOperacaoId.setValue(value);
            if (aAplicativoOperacaoId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setAplicativoOperacaoId(Long value) {
        aAplicativoOperacaoId.setValue(value);
        if (aAplicativoOperacaoId.isModified()) {
            setModified(true);
        }
    }
    
    public void setAplicativoOperacaoId(Object value) {
        aAplicativoOperacaoId.setValue(value);
        if (aAplicativoOperacaoId.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyAplicativoOperacaoId() {
        if (!aAplicativoOperacaoId.isNull()) {
            aAplicativoOperacaoId.setNull(true);
            setModified(true);
        }
    }
    
    public DomId getAplicativoOperacaoId() {
        return aAplicativoOperacaoId;
    }
    
    public DomId oldAplicativoOperacaoId() {
        return oAplicativoOperacaoId;
    }
    
    public Long valueOfAplicativoOperacaoId() {
        return aAplicativoOperacaoId.getValue();
    }
    
    public boolean isAplicativoOperacaoIdModified() {
        return aAplicativoOperacaoId.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo MASCARA_VALOR">
    
    public EntVariavelAplicativo mascaraValor(String value) {
        setMascaraValor(value);
        return this;
    }
    
    public void setMascaraValor(DomText value) {
        if (value == null || value.isNull()) {
            nullifyMascaraValor();
        } else {
            aMascaraValor.setValue(value.getValue());
            if (aMascaraValor.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setMascaraValor(String value) {
        if (value == null) {
            nullifyMascaraValor();
        } else {
            aMascaraValor.setValue(value);
            if (aMascaraValor.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setMascaraValor(Object value) {
        aMascaraValor.setValue(value);
        if (aMascaraValor.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyMascaraValor() {
        if (!aMascaraValor.isNull()) {
            aMascaraValor.setNull(true);
            setModified(true);
        }
    }
    
    public DomText getMascaraValor() {
        return aMascaraValor;
    }
    
    public DomText oldMascaraValor() {
        return oMascaraValor;
    }
    
    public String valueOfMascaraValor() {
        return aMascaraValor.getValue();
    }
    
    public boolean isMascaraValorModified() {
        return aMascaraValor.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo TIPO_VARIAVEL_APLICATIVO_ID">
    
    public EntVariavelAplicativo tipoVariavelAplicativoId(Long value) {
        setTipoVariavelAplicativoId(value);
        return this;
    }
    
    public void setTipoVariavelAplicativoId(DomId value) {
        if (value == null || value.isNull()) {
            nullifyTipoVariavelAplicativoId();
        } else {
            aTipoVariavelAplicativoId.setValue(value.getValue());
            if (aTipoVariavelAplicativoId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setTipoVariavelAplicativoId(String value) {
        if (value == null) {
            nullifyTipoVariavelAplicativoId();
        } else {
            aTipoVariavelAplicativoId.setValue(value);
            if (aTipoVariavelAplicativoId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setTipoVariavelAplicativoId(Long value) {
        aTipoVariavelAplicativoId.setValue(value);
        if (aTipoVariavelAplicativoId.isModified()) {
            setModified(true);
        }
    }
    
    public void setTipoVariavelAplicativoId(Object value) {
        aTipoVariavelAplicativoId.setValue(value);
        if (aTipoVariavelAplicativoId.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyTipoVariavelAplicativoId() {
        if (!aTipoVariavelAplicativoId.isNull()) {
            aTipoVariavelAplicativoId.setNull(true);
            setModified(true);
        }
    }
    
    public DomId getTipoVariavelAplicativoId() {
        return aTipoVariavelAplicativoId;
    }
    
    public DomId oldTipoVariavelAplicativoId() {
        return oTipoVariavelAplicativoId;
    }
    
    public Long valueOfTipoVariavelAplicativoId() {
        return aTipoVariavelAplicativoId.getValue();
    }
    
    public boolean isTipoVariavelAplicativoIdModified() {
        return aTipoVariavelAplicativoId.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo VALOR_DEFAULT">
    
    public EntVariavelAplicativo valorDefault(String value) {
        setValorDefault(value);
        return this;
    }
    
    public void setValorDefault(DomProperties value) {
        if (value == null || value.isNull()) {
            nullifyValorDefault();
        } else {
            aValorDefault.setValue(value.getValue());
            if (aValorDefault.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setValorDefault(String value) {
        if (value == null) {
            nullifyValorDefault();
        } else {
            aValorDefault.setValue(value);
            if (aValorDefault.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setValorDefault(Object value) {
        aValorDefault.setValue(value);
        if (aValorDefault.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyValorDefault() {
        if (!aValorDefault.isNull()) {
            aValorDefault.setNull(true);
            setModified(true);
        }
    }
    
    public DomProperties getValorDefault() {
        return aValorDefault;
    }
    
    public DomProperties oldValorDefault() {
        return oValorDefault;
    }
    
    public String valueOfValorDefault() {
        return aValorDefault.getValue();
    }
    
    public boolean isValorDefaultModified() {
        return aValorDefault.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo UNIDADE_MEDIDA">
    
    public EntVariavelAplicativo unidadeMedida(String value) {
        setUnidadeMedida(value);
        return this;
    }
    
    public void setUnidadeMedida(DomUpper value) {
        if (value == null || value.isNull()) {
            nullifyUnidadeMedida();
        } else {
            aUnidadeMedida.setValue(value.getValue());
            if (aUnidadeMedida.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setUnidadeMedida(String value) {
        if (value == null) {
            nullifyUnidadeMedida();
        } else {
            aUnidadeMedida.setValue(value);
            if (aUnidadeMedida.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setUnidadeMedida(Object value) {
        aUnidadeMedida.setValue(value);
        if (aUnidadeMedida.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyUnidadeMedida() {
        if (!aUnidadeMedida.isNull()) {
            aUnidadeMedida.setNull(true);
            setModified(true);
        }
    }
    
    public DomUpper getUnidadeMedida() {
        return aUnidadeMedida;
    }
    
    public DomUpper oldUnidadeMedida() {
        return oUnidadeMedida;
    }
    
    public String valueOfUnidadeMedida() {
        return aUnidadeMedida.getValue();
    }
    
    public boolean isUnidadeMedidaModified() {
        return aUnidadeMedida.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo PROCESSO_APLICATIVO_ID">
    
    public EntVariavelAplicativo processoAplicativoId(Long value) {
        setProcessoAplicativoId(value);
        return this;
    }
    
    public void setProcessoAplicativoId(DomId value) {
        if (value == null || value.isNull()) {
            nullifyProcessoAplicativoId();
        } else {
            aProcessoAplicativoId.setValue(value.getValue());
            if (aProcessoAplicativoId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setProcessoAplicativoId(String value) {
        if (value == null) {
            nullifyProcessoAplicativoId();
        } else {
            aProcessoAplicativoId.setValue(value);
            if (aProcessoAplicativoId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setProcessoAplicativoId(Long value) {
        aProcessoAplicativoId.setValue(value);
        if (aProcessoAplicativoId.isModified()) {
            setModified(true);
        }
    }
    
    public void setProcessoAplicativoId(Object value) {
        aProcessoAplicativoId.setValue(value);
        if (aProcessoAplicativoId.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyProcessoAplicativoId() {
        if (!aProcessoAplicativoId.isNull()) {
            aProcessoAplicativoId.setNull(true);
            setModified(true);
        }
    }
    
    public DomId getProcessoAplicativoId() {
        return aProcessoAplicativoId;
    }
    
    public DomId oldProcessoAplicativoId() {
        return oProcessoAplicativoId;
    }
    
    public Long valueOfProcessoAplicativoId() {
        return aProcessoAplicativoId.getValue();
    }
    
    public boolean isProcessoAplicativoIdModified() {
        return aProcessoAplicativoId.isModified();
    }
    // </editor-fold>
    // </editor-fold>
    
    @Override
    protected void processDeleteRestrict() throws AdsException {
        // Nullify cascade ZTEST.FORMULA_EXECUCAO.FK_FOREXC_VARIAVEL_RECEBE_VALOR
        {
            EntFormulaExecucao external = new EntFormulaExecucao(ctx);
            external.findByVariavelRecebeValor(valueOfId());
            if (external.next()) {
                throw new AdsException("ZTEST.FORMULA_EXECUCAO.FK_FOREXC_VARIAVEL_RECEBE_VALOR.RESTRICTED",
                        AdsException.ERROR,
                        "Não pode excluir porque existem Fórmulas para execuções fazendo referencia para este registro");
            }
            external.close();
        }
        // Nullify cascade ZTEST.REGRA_VARIAVEL_PLANO_EXECUCAO.FK_RGVVPE_VARIAVEL_APLICATIVO
        {
            EntRegraVariavelPlanoExecucao external = new EntRegraVariavelPlanoExecucao(ctx);
            external.findByVariavelAplicativo(valueOfId());
            if (external.next()) {
                throw new AdsException("ZTEST.REGRA_VARIAVEL_PLANO_EXECUCAO.FK_RGVVPE_VARIAVEL_APLICATIVO.RESTRICTED",
                        AdsException.ERROR,
                        "Não pode excluir porque existem Regras para os valores de variáveis nos planos de execuções fazendo referencia para este registro");
            }
            external.close();
        }
        // Nullify cascade ZTEST.VALOR_VARIAVEL_ENSAIO.FK_VAVAEN_VARIAVEL_APLICATIVO
        {
            EntValorVariavelEnsaio external = new EntValorVariavelEnsaio(ctx);
            external.findByVariavelAplicativo(valueOfId());
            if (external.next()) {
                throw new AdsException("ZTEST.VALOR_VARIAVEL_ENSAIO.FK_VAVAEN_VARIAVEL_APLICATIVO.RESTRICTED",
                        AdsException.ERROR,
                        "Não pode excluir porque existem Valores das variávéis nos ensaios fazendo referencia para este registro");
            }
            external.close();
        }
        // Nullify cascade ZTEST.VARIAVEL_UTILIZADA_FORMULA.FK_VUNAFO_VARIAVEL_EXECUCAO
        {
            EntVariavelUtilizadaFormula external = new EntVariavelUtilizadaFormula(ctx);
            external.findByVariavelExecucao(valueOfId());
            if (external.next()) {
                throw new AdsException("ZTEST.VARIAVEL_UTILIZADA_FORMULA.FK_VUNAFO_VARIAVEL_EXECUCAO.RESTRICTED",
                        AdsException.ERROR,
                        "Não pode excluir porque existem Variávéis utilizadas nas fórmulas fazendo referencia para este registro");
            }
            external.close();
        }
    }
    
    // <editor-fold defaultstate="collapsed" desc="getErrors">
    /**
     * Traduz um erro recebido do banco de dados para um AdsException
     */
    @Override
    public AdsException getErrors(String errorMsg, int transaction) {
        AdsException e;
        String msg = errorMsg.toUpperCase();
        
        if (transaction == DELETE_TRANSACTION) {
            if (msg.indexOf("FK_FOREXC_VARIAVEL_RECEBE_VALOR") >= 0) {
                e = new AdsException("ZTEST.FORMULA_EXECUCAO.FK_FOREXC_VARIAVEL_RECEBE_VALOR.RESTRICTED", 
                        Severity.ERROR,
                        "Não pode excluir porque existem Fórmulas para execuções fazendo referencia para este registro! (FK_FOREXC_VARIAVEL_RECEBE_VALOR)");
                return e;
            } else if (msg.indexOf("FK_RGVVPE_VARIAVEL_APLICATIVO") >= 0) {
                e = new AdsException("ZTEST.REGRA_VARIAVEL_PLANO_EXECUCAO.FK_RGVVPE_VARIAVEL_APLICATIVO.RESTRICTED", 
                        Severity.ERROR,
                        "Não pode excluir porque existem Regras para os valores de variáveis nos planos de execuções fazendo referencia para este registro! (FK_RGVVPE_VARIAVEL_APLICATIVO)");
                return e;
            } else if (msg.indexOf("FK_VAVAEN_VARIAVEL_APLICATIVO") >= 0) {
                e = new AdsException("ZTEST.VALOR_VARIAVEL_ENSAIO.FK_VAVAEN_VARIAVEL_APLICATIVO.RESTRICTED", 
                        Severity.ERROR,
                        "Não pode excluir porque existem Valores das variávéis nos ensaios fazendo referencia para este registro! (FK_VAVAEN_VARIAVEL_APLICATIVO)");
                return e;
            } else if (msg.indexOf("FK_VUNAFO_VARIAVEL_EXECUCAO") >= 0) {
                e = new AdsException("ZTEST.VARIAVEL_UTILIZADA_FORMULA.FK_VUNAFO_VARIAVEL_EXECUCAO.RESTRICTED", 
                        Severity.ERROR,
                        "Não pode excluir porque existem Variávéis utilizadas nas fórmulas fazendo referencia para este registro! (FK_VUNAFO_VARIAVEL_EXECUCAO)");
                return e;
            } else {
                e = new AdsException("ZTEST.VARIAVEL_APLICATIVO.GET_ERRORS_UNKNOWN",
                        AdsException.UNKNOWN,
                        "Erro não esperado: " + errorMsg);
            }
        } else {
            if (msg.indexOf("UK_VARAPL_VAR_PROC") >= 0) {
                e = new AdsException("ZTEST.VARIAVEL_APLICATIVO.UK_VARAPL_VAR_PROC", 
                        Severity.ERROR,
                        "Registro duplicado! O nome da variável do aplicativo deve ser único em um processo do aplicativo! Nome da variável ${NOME}, Aplicativo de operação ${APLICATIVO_OPERACAO_ID}, Processo do aplicativo ${PROCESSO_APLICATIVO_ID} (UK_VARAPL_VAR_PROC)");
                return e;
            } else if (msg.indexOf("FK_VARAPL_PROCESSO_APLICATIVO") >= 0) {
                e = new AdsException("ZTEST.VARIAVEL_APLICATIVO.FK_VARAPL_PROCESSO_APLICATIVO", 
                        Severity.ERROR,
                        "Registro não cadastrado para PROCESSO_APLICATIVO! (FK_VARAPL_PROCESSO_APLICATIVO)");
                return e;
            } else if (msg.indexOf("FK_VARAPL_TIPO_VARIAVEL_APLICATIVO") >= 0) {
                e = new AdsException("ZTEST.VARIAVEL_APLICATIVO.FK_VARAPL_TIPO_VARIAVEL_APLICATIVO", 
                        Severity.ERROR,
                        "Registro não cadastrado para TIPO_VARIAVEL_APLICATIVO! (FK_VARAPL_TIPO_VARIAVEL_APLICATIVO)");
                return e;
            } else if (msg.indexOf("FK_VARAPL_APLICATIVO_OPERACAO") >= 0) {
                e = new AdsException("ZTEST.VARIAVEL_APLICATIVO.FK_VARAPL_APLICATIVO_OPERACAO", 
                        Severity.ERROR,
                        "Registro não cadastrado para APLICATIVO_OPERACAO! (FK_VARAPL_APLICATIVO_OPERACAO)");
                return e;
            } else if (msg.indexOf("PK_VARAPL") >= 0) {
                e = new AdsException("ZTEST.VARIAVEL_APLICATIVO.PK_VARAPL", 
                        Severity.ERROR,
                        "ID duplicado! (PK_VARAPL)");
                return e;
            } else {
                e = new AdsException("ZTEST.VARIAVEL_APLICATIVO.GET_ERRORS_UNKNOWN",
                        AdsException.UNKNOWN,
                        "Erro não esperado: " + errorMsg);
            }
        }
        return e;
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Entity Information">
    
    public String getEntityName() {
        return ENTITY_NAME;
    }
    
    public String getTableName() {
        return TABLE_NAME;
    }
    
    public String idSequenceName() {
        return "PK_SEQUENCE";
    }
    
    private ArrayList<Field> allAttributes;
    public ArrayList<Field> getAllAttributes() {
        if (allAttributes == null) {
            allAttributes = new ArrayList<Field>();
            allAttributes.add(aId);
            allAttributes.add(aNome);
            allAttributes.add(aAplicativoOperacaoId);
            allAttributes.add(aMascaraValor);
            allAttributes.add(aTipoVariavelAplicativoId);
            allAttributes.add(aValorDefault);
            allAttributes.add(aUnidadeMedida);
            allAttributes.add(aProcessoAplicativoId);
        }
        return allAttributes;
    }
    
    /**
     * Retorna o valor da primeira UK da entidade
     * Se ela for composta, retorna a concatenação de toda a combinação
     * de atributos separados por um espaço.
     */
    public String valueOfUk() {
        return getNome().toString() +
                " " + getAplicativoOperacaoId().toString() +
                " " + getProcessoAplicativoId().toString();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Relationships">
    
    
    public void findByNomeAplicativoOperacaoIdProcessoAplicativoId(String nome, long aplicativoOperacaoId, long processoAplicativoId) throws AdsException {
        findBy(new String[] {"NOME", "APLICATIVO_OPERACAO_ID", "PROCESSO_APLICATIVO_ID"},
                new Object[] {nome, aplicativoOperacaoId, processoAplicativoId});
    }
    
    private EntProcessoAplicativo eProcessoAplicativo;
    
    public EntProcessoAplicativo findProcessoAplicativo() throws AdsException {
        if (getProcessoAplicativoId().isNull()) {
            return null;
        }
        if (eProcessoAplicativo == null || !valueOfProcessoAplicativoId().equals(eProcessoAplicativo.valueOfId())) {
            eProcessoAplicativo = new EntProcessoAplicativo(ctx);
            eProcessoAplicativo.find(valueOfProcessoAplicativoId());
        }
        return eProcessoAplicativo;
    }
    
    /**
     * Ativa o join desta entidade com PROCESSO_APLICATIVO
     * através do atributo PROCESSO_APLICATIVO_ID
     */
    public EntProcessoAplicativo joinProcessoAplicativo() {
        return joinProcessoAplicativo(null);
    }
    public EntProcessoAplicativo joinProcessoAplicativo(String alias) {
        EntProcessoAplicativo entity = new EntProcessoAplicativo(ctx);
        if (alias != null) {
            entity.setAlias(alias);
        }
        Join newJoin = new Join(getProcessoAplicativoId(), entity);
        entity.setJoinedBy(newJoin);
        this.join(newJoin);
        return entity;
    }
    
    public void findByProcessoAplicativo(long id, String sqlAppend) throws AdsException {
        find("select ID from VARIAVEL_APLICATIVO where PROCESSO_APLICATIVO_ID = ? " + sqlAppend);
        sqlSetLong(1,id);
    }
    
    public void findByProcessoAplicativo(long id) throws AdsException {
        findByProcessoAplicativo(id,"");
    }
    
    public void findByProcessoAplicativo(Entity entidade) throws AdsException {
        findByProcessoAplicativo(entidade.valueOfId(),"");
    }
    
    public void findByProcessoAplicativo(Entity entidade, String sqlAppend) throws AdsException {
        findByProcessoAplicativo(entidade.valueOfId(),sqlAppend);
    }
    
    private EntTipoVariavelAplicativo eTipoVariavelAplicativo;
    
    public EntTipoVariavelAplicativo findTipoVariavelAplicativo() throws AdsException {
        if (getTipoVariavelAplicativoId().isNull()) {
            return null;
        }
        if (eTipoVariavelAplicativo == null || !valueOfTipoVariavelAplicativoId().equals(eTipoVariavelAplicativo.valueOfId())) {
            eTipoVariavelAplicativo = new EntTipoVariavelAplicativo(ctx);
            eTipoVariavelAplicativo.find(valueOfTipoVariavelAplicativoId());
        }
        return eTipoVariavelAplicativo;
    }
    
    /**
     * Ativa o join desta entidade com TIPO_VARIAVEL_APLICATIVO
     * através do atributo TIPO_VARIAVEL_APLICATIVO_ID
     */
    public EntTipoVariavelAplicativo joinTipoVariavelAplicativo() {
        return joinTipoVariavelAplicativo(null);
    }
    public EntTipoVariavelAplicativo joinTipoVariavelAplicativo(String alias) {
        EntTipoVariavelAplicativo entity = new EntTipoVariavelAplicativo(ctx);
        if (alias != null) {
            entity.setAlias(alias);
        }
        Join newJoin = new Join(getTipoVariavelAplicativoId(), entity);
        entity.setJoinedBy(newJoin);
        this.join(newJoin);
        return entity;
    }
    
    public void findByTipoVariavelAplicativo(long id, String sqlAppend) throws AdsException {
        find("select ID from VARIAVEL_APLICATIVO where TIPO_VARIAVEL_APLICATIVO_ID = ? " + sqlAppend);
        sqlSetLong(1,id);
    }
    
    public void findByTipoVariavelAplicativo(long id) throws AdsException {
        findByTipoVariavelAplicativo(id,"");
    }
    
    public void findByTipoVariavelAplicativo(Entity entidade) throws AdsException {
        findByTipoVariavelAplicativo(entidade.valueOfId(),"");
    }
    
    public void findByTipoVariavelAplicativo(Entity entidade, String sqlAppend) throws AdsException {
        findByTipoVariavelAplicativo(entidade.valueOfId(),sqlAppend);
    }
    
    private EntAplicativoOperacao eAplicativoOperacao;
    
    public EntAplicativoOperacao findAplicativoOperacao() throws AdsException {
        if (getAplicativoOperacaoId().isNull()) {
            return null;
        }
        if (eAplicativoOperacao == null || !valueOfAplicativoOperacaoId().equals(eAplicativoOperacao.valueOfId())) {
            eAplicativoOperacao = new EntAplicativoOperacao(ctx);
            eAplicativoOperacao.find(valueOfAplicativoOperacaoId());
        }
        return eAplicativoOperacao;
    }
    
    /**
     * Ativa o join desta entidade com APLICATIVO_OPERACAO
     * através do atributo APLICATIVO_OPERACAO_ID
     */
    public EntAplicativoOperacao joinAplicativoOperacao() {
        return joinAplicativoOperacao(null);
    }
    public EntAplicativoOperacao joinAplicativoOperacao(String alias) {
        EntAplicativoOperacao entity = new EntAplicativoOperacao(ctx);
        if (alias != null) {
            entity.setAlias(alias);
        }
        Join newJoin = new Join(getAplicativoOperacaoId(), entity);
        entity.setJoinedBy(newJoin);
        this.join(newJoin);
        return entity;
    }
    
    public void findByAplicativoOperacao(long id, String sqlAppend) throws AdsException {
        find("select ID from VARIAVEL_APLICATIVO where APLICATIVO_OPERACAO_ID = ? " + sqlAppend);
        sqlSetLong(1,id);
    }
    
    public void findByAplicativoOperacao(long id) throws AdsException {
        findByAplicativoOperacao(id,"");
    }
    
    public void findByAplicativoOperacao(Entity entidade) throws AdsException {
        findByAplicativoOperacao(entidade.valueOfId(),"");
    }
    
    public void findByAplicativoOperacao(Entity entidade, String sqlAppend) throws AdsException {
        findByAplicativoOperacao(entidade.valueOfId(),sqlAppend);
    }
    
    /**
     * Limpa os objetos normalizados da entidade
     */
    public void clearRelatedObjects() {
        eProcessoAplicativo = null;
        eTipoVariavelAplicativo = null;
        eAplicativoOperacao = null;
    }
    /**
     * Retorna os registros de FORMULA_EXECUCAO que referenciam este registro através do atributo VARIAVEL_RECEBE_VALOR_ID
     */
    public EntFormulaExecucao findAllFormulaExecucaoVariavelRecebeValor() throws AdsException {
        return findAllFormulaExecucaoVariavelRecebeValor("order by ID");
    }
    
    /**
     * Retorna os registros de FORMULA_EXECUCAO que referenciam este registro através do atributo VARIAVEL_RECEBE_VALOR_ID
     */
    public EntFormulaExecucao findAllFormulaExecucaoVariavelRecebeValor(String sqlAppend) throws AdsException {
        EntFormulaExecucao out = new EntFormulaExecucao(ctx);
        out.find("select ID from FORMULA_EXECUCAO where VARIAVEL_RECEBE_VALOR_ID = " + valueOfId() + " " + sqlAppend);
        return out;
    }
    
    /**
     * Retorna os registros de REGRA_VARIAVEL_PLANO_EXECUCAO que referenciam este registro através do atributo VARIAVEL_APLICATIVO_ID
     */
    public EntRegraVariavelPlanoExecucao findAllRegraVariavelPlanoExecucaoVariavelAplicativo() throws AdsException {
        return findAllRegraVariavelPlanoExecucaoVariavelAplicativo("order by ID");
    }
    
    /**
     * Retorna os registros de REGRA_VARIAVEL_PLANO_EXECUCAO que referenciam este registro através do atributo VARIAVEL_APLICATIVO_ID
     */
    public EntRegraVariavelPlanoExecucao findAllRegraVariavelPlanoExecucaoVariavelAplicativo(String sqlAppend) throws AdsException {
        EntRegraVariavelPlanoExecucao out = new EntRegraVariavelPlanoExecucao(ctx);
        out.find("select ID from REGRA_VARIAVEL_PLANO_EXECUCAO where VARIAVEL_APLICATIVO_ID = " + valueOfId() + " " + sqlAppend);
        return out;
    }
    
    /**
     * Retorna os registros de VALOR_VARIAVEL_ENSAIO que referenciam este registro através do atributo VARIAVEL_APLICATIVO_ID
     */
    public EntValorVariavelEnsaio findAllValorVariavelEnsaioVariavelAplicativo() throws AdsException {
        return findAllValorVariavelEnsaioVariavelAplicativo("order by ID");
    }
    
    /**
     * Retorna os registros de VALOR_VARIAVEL_ENSAIO que referenciam este registro através do atributo VARIAVEL_APLICATIVO_ID
     */
    public EntValorVariavelEnsaio findAllValorVariavelEnsaioVariavelAplicativo(String sqlAppend) throws AdsException {
        EntValorVariavelEnsaio out = new EntValorVariavelEnsaio(ctx);
        out.find("select ID from VALOR_VARIAVEL_ENSAIO where VARIAVEL_APLICATIVO_ID = " + valueOfId() + " " + sqlAppend);
        return out;
    }
    
    /**
     * Retorna os registros de VARIAVEL_UTILIZADA_FORMULA que referenciam este registro através do atributo VARIAVEL_EXECUCAO_ID
     */
    public EntVariavelUtilizadaFormula findAllVariavelUtilizadaFormulaVariavelExecucao() throws AdsException {
        return findAllVariavelUtilizadaFormulaVariavelExecucao("order by ID");
    }
    
    /**
     * Retorna os registros de VARIAVEL_UTILIZADA_FORMULA que referenciam este registro através do atributo VARIAVEL_EXECUCAO_ID
     */
    public EntVariavelUtilizadaFormula findAllVariavelUtilizadaFormulaVariavelExecucao(String sqlAppend) throws AdsException {
        EntVariavelUtilizadaFormula out = new EntVariavelUtilizadaFormula(ctx);
        out.find("select ID from VARIAVEL_UTILIZADA_FORMULA where VARIAVEL_EXECUCAO_ID = " + valueOfId() + " " + sqlAppend);
        return out;
    }
    
    
    /**
     * Método que copia os valores dos atributos
     * para os valores respectivos old 
     */
    public void saveOldAtributes() {
        oProcessoAplicativoId.setValue(aProcessoAplicativoId);
        oMascaraValor.setValue(aMascaraValor);
        oUnidadeMedida.setValue(aUnidadeMedida);
        oValorDefault.setValue(aValorDefault);
        oTipoVariavelAplicativoId.setValue(aTipoVariavelAplicativoId);
        oAplicativoOperacaoId.setValue(aAplicativoOperacaoId);
        oNome.setValue(aNome);
        oId.setValue(aId);
    }
    
    /**
     * Método que retorna as regras da entidade
     * @return ArrayList com as regras ou null caso não existir nenhuma regra
     */
    public ArrayList getAllRules() {
        ArrayList<EntityRule> out = new ArrayList<EntityRule>();
        {
            PrimaryKeyRule rule = new PrimaryKeyRule();
            rule.setEntity(EntVariavelAplicativo.class);
            rule.setName("PK_VARAPL");
            rule.setPkAttribute(new DomId("ID",""));
            out.add(rule);
        }
        {
            ForeignKeyRule rule = new ForeignKeyRule();
            rule.setEntity(EntVariavelAplicativo.class);
            rule.setAssociatedEntity(EntAplicativoOperacao.class);
            rule.setName("FK_VARAPL_APLICATIVO_OPERACAO");
            rule.addAttribute(new DomId("APLICATIVO_OPERACAO_ID",""));
            out.add(rule);
        }
        {
            ForeignKeyRule rule = new ForeignKeyRule();
            rule.setEntity(EntVariavelAplicativo.class);
            rule.setAssociatedEntity(EntProcessoAplicativo.class);
            rule.setName("FK_VARAPL_PROCESSO_APLICATIVO");
            rule.addAttribute(new DomId("PROCESSO_APLICATIVO_ID",""));
            out.add(rule);
        }
        {
            ForeignKeyRule rule = new ForeignKeyRule();
            rule.setEntity(EntVariavelAplicativo.class);
            rule.setAssociatedEntity(EntTipoVariavelAplicativo.class);
            rule.setName("FK_VARAPL_TIPO_VARIAVEL_APLICATIVO");
            rule.addAttribute(new DomId("TIPO_VARIAVEL_APLICATIVO_ID",""));
            out.add(rule);
        }
        {
            UniqueKeyRule rule = new UniqueKeyRule();
            rule.setEntity(EntVariavelAplicativo.class);
            rule.setName("UK_VARAPL_VAR_PROC");
            rule.addAttribute(new DomUpper("NOME",""));
            rule.addAttribute(new DomId("APLICATIVO_OPERACAO_ID",""));
            rule.addAttribute(new DomId("PROCESSO_APLICATIVO_ID",""));
            out.add(rule);
        }
        return out;
    }
    // </editor-fold>
    
    @Override
    public void fillDefaultValues() throws AdsException {
        if (aId.isNull()) {
            aId.setValue("" + ctx.getNextVal("pk_sequence"));
        }
    }
    
    // <editor-fold defaultstate="collapsed" desc="Métodos customizados">
}
